package org.example.study4;
/**
 * 用类对象做为锁对象
 * 展示了使用全局类对象（String.class）作为锁来保护静态变量的线程安全机制。
 * 虽然 count 是静态变量，但通过锁定 String.class，所有线程强制串行执行 count++，最终结果严格等于预期的 10 万。
 */
public class Demo_410 {
    public static void main(String[] args) throws InterruptedException {
        // 初始化两个不同的 Counter410 实例
        Counter410 counter = new Counter410(); // 实例1
        Counter410 counter1 = new Counter410(); // 实例2

        // 创建两个线程，分别操作不同的实例
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 50000; i++) {
                counter.increase(); // 线程1调用实例1的 increase()
            }
        });

        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 50000; i++) {
                counter1.increase(); // 线程2调用实例2的 increase()
            }
        });

        // 启动线程
        t1.start();
        t2.start();

        // 等待线程结束
        t1.join();
        t2.join();

        // 输出结果（正确应为 10 万）
        System.out.println("count = " + counter.count); // 实际访问的是静态变量 Counter410.count
    }
}


class Counter410 {
    public static int count = 0; // 静态变量，类级别共享
    // 构造方法
    public Counter410() {
        System.out.println("构造方法执行...");
    }

    // 静态代码块（类加载时执行一次）
    static {
        System.out.println("加载一个类"); // 首次使用 Counter410 时触发
    }

    // 实例代码块（每次创建实例时执行）
    {
        System.out.println("初始化一个对象"); // 每个实例初始化时触发
    }

    /**
     * 累加方法（使用全局类锁 String.class）
     */
    public void increase() {
        synchronized (String.class) { // 锁定全局类对象 String.class
            count++; // 原子操作（在同步保护下）
        }
    }
}
/*运行：
加载一个类
初始化一个对象
构造方法执行...
初始化一个对象
构造方法执行...
count = 100000*/
/*
1. 全局类锁的线程安全机制
synchronized (String.class)：锁定 String 类的 Class 对象。
所有线程（无论操作哪个 Counter410 实例）在调用 increase() 时，竞争同一把全局锁。
保证静态变量 count 的修改是原子的。

2. 静态变量与全局锁的匹配
静态变量 count：属于类级别，所有实例共享。
全局锁的作用域：锁的作用域与变量的作用域无关，但通过全局锁强制所有线程串行修改 count。*/


/*
潜在问题
1. 全局类锁的风险
锁对象不可控：String.class 是 JVM 全局唯一的类对象，若其他无关代码也使用 synchronized (String.class)，可能导致：
性能下降：无关代码竞争同一锁，增加线程阻塞。
死锁风险：若其他代码嵌套使用 String.class 锁，可能引发死锁。

2. 设计建议
避免使用全局类锁：应优先使用与共享变量直接关联的锁（如类锁 Counter410.class 或静态锁对象）。
示例改进：

public void increase() {
    synchronized (Counter410.class) { // 使用当前类的锁
        count++;
    }
}
*/




/*总结
核心设计：通过全局类锁（String.class）强制所有线程串行修改静态变量，确保线程安全。
解决问题：验证了即使使用外部类锁，只要锁对象唯一，仍可保护共享资源。
现象：结果正确，但锁设计存在风险。
实际意义：展示了锁对象的选择对线程安全的影响，同时警示全局锁的潜在问题。*/